Promise 方法

🚀 Promise 的含义：Promise 是异步编程的一种解决方案。

Promise 对象是一个构造函数。对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和 rejected（已失败）。

特点

• new Promise 新建后就会立即执行。
• 无法取消 Promise。
• 不设置回调函数，内部抛出的错误不会反应到外部。

基本用法

const promise = new Promise(function (resolve, reject) {});

then

promise.then(
  function (value) {
    // success
  },
  function (error) {
    // failure
  }
);

catch

一般来说，不使用 then()方法的第二个参数。，总是使用 catch 方法。抛出的错误不会传递到外层代码，“Promise 会吃掉错误”。

promise
  .then(function (data) {
    //cb
    // success
  })
  .catch(function (err) {
    // error
  });

finally

不管 Promise 对象最后状态如何，都会执行的操作。

promise.then(result => {})
  .catch(error => {})
  .finally(() => {});

源码实现原理。

Promise.prototype.finally = function (callback) {
  let P = this.constructor;
  return this.then(
    (value) => P.resolve(callback()).then(() => value),
    (reason) =>
      P.resolve(callback()).then(() => {
        throw reason;
      })
  );
};

all

等待全部请求都成功，则成功，否则失败 没有自己的 catch 方法，就会调用 Promise.all()的 catch 方法。

const resolved = Promise.resolve(42);
const rejected = new Promise(function (resolve, reject) {
  setTimeout(() => {
    console.log("请求是否停止");
    reject(-1);
  }, 3000);
});

const promise = Promise.all([resolved, rejected]);

promise.then(function (results) {
  console.log(results);
}).catch(error => {})

race

一旦有结果，返回当前状态。不影响其他请求

const resolved = Promise.resolve(42);
const rejected = new Promise(function (resolve, reject) {
  setTimeout(() => {
    console.log("请求是否停止");
    reject(-1);
  }, 3000);
});

const promise = Promise.race([resolved, rejected]);

promise.then(function (results) {
  console.log(results);
});

allSettled

异步操作是否都结束，返回状态组

const resolved = Promise.resolve(42);
const rejected = Promise.reject(-1);
const promise = Promise.allSettled([resolved, rejected]);

promise.then(function (results) {
  console.log(results);
});
// [
//    { status: 'fulfilled', value: 42 },
//    { status: 'rejected', reason: -1 }
// ]

any

有一个成功，返回成功，都失败，返回失败

var resolved = Promise.resolve(42);
var rejected = Promise.reject(-1);
var alsoRejected = Promise.reject(Infinity);

Promise.any([resolved, rejected, alsoRejected]).then(function (result) {
  console.log(result); // 42
});

Promise.any([rejected, alsoRejected]).catch(function (results) {
  console.log(results instanceof AggregateError); // true
  console.log(results.errors); // [-1, Infinity]
});

resolve

转为 Promise 对象，然后就立即执行 thenable 对象的 then() 方法。

Promise.resolve("foo");
// 等价于
new Promise((resolve) => resolve("foo"));

reject

返回一个新的 Promise 实例，状态为 rejected，回调函数会立即执行。

const p = Promise.reject("出错了");
// 等同于
const p = new Promise((resolve, reject) => reject("出错了"));

try

const f = () => console.log("now");
(() => new Promise((resolve) => resolve(f())))();
console.log("next");
// now
// next

// 提供Promise.try方法替代上面的写法。

const f = () => console.log("now");
Promise.try(f);
console.log("next");
// now
// next

应用

const preloadImage = function (path) {
  return new Promise(function (resolve, reject) {
    const image = new Image();
    image.onload = resolve;
    image.onerror = reject;
    image.src = path;
  });
};